// 监听来自插件的消息
chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
  console.log("收到消息:", request);

  // 无论操作成功与否，都先返回当前页面的URL，帮助诊断问题
  if (request.action === "checkPage") {
    const pageInfo = {
      url: window.location.href,
      title: document.title,
      isApifox: window.location.href.includes("apifox"),
    };
    sendResponse(pageInfo);
    return true;
  }

  if (request.action === "copyMethod" || request.action === "copyClass") {
    try {
      // 如果用户提供了手动输入的API信息，则使用手动输入的信息
      if (request.apiInfo) {
        const manualApiInfo = {
          name: request.apiInfo.name || "",
          description: request.apiInfo.description || "",
          path: request.apiInfo.path || "",
          method: (request.apiInfo.method || "get").toLowerCase(),
          hasParams: request.apiInfo.hasParams || false,
        };

        // 验证路径是否有效
        if (!manualApiInfo.path || manualApiInfo.path === "/") {
          console.error("无效的API路径");
          sendResponse({
            success: false,
            message: "请输入有效的API路径，不能只是单个斜杠 '/'",
          });
          return true;
        }

        console.log("使用手动输入的API信息:", manualApiInfo);

        // 如果用户没有输入方法名，自动生成方法名
        if (!manualApiInfo.name && manualApiInfo.path) {
          manualApiInfo.name = generateMethodName(
            manualApiInfo.path,
            manualApiInfo.method
          );
          console.log("自动生成的方法名:", manualApiInfo.name);
        }

        let code;
        if (request.action === "copyMethod") {
          code = generateMethodCode(manualApiInfo);
        } else {
          code = generateClassCode(manualApiInfo);
        }

        copyToClipboard(code);
        sendResponse({ success: true });
        return true;
      }

      // 尝试自动提取API信息
      const apiInfo = extractApiInfo();

      // 使用自动提取的API信息
      if (!apiInfo) {
        console.error("无法提取API信息");
        sendResponse({
          success: false,
          message: "无法提取API信息，请使用手动输入模式输入API路径",
        });
        return true;
      }

      // 验证提取的API路径是否有效（不仅仅是单个斜杠）
      if (apiInfo.path === "/") {
        console.error("提取的API路径无效（仅为单个斜杠）");
        sendResponse({
          success: false,
          message: "提取的API路径无效，请使用手动输入模式输入完整的API路径",
        });
        return true;
      }

      console.log("已提取API信息:", apiInfo);

      let code;
      if (request.action === "copyMethod") {
        code = generateMethodCode(apiInfo);
      } else {
        code = generateClassCode(apiInfo);
      }

      console.log("生成的代码:", code);
      copyToClipboard(code);
      sendResponse({ success: true });
    } catch (error) {
      console.error("生成代码时出错:", error);
      sendResponse({ success: false, message: error.message });
    }
  }
  return true;
});

// 在页面加载完成后运行
document.addEventListener("DOMContentLoaded", function () {
  console.log("Apifox代码生成器：DOMContentLoaded事件触发");
  initializeExtension();
});

// 如果DOMContentLoaded已经触发过，则立即执行
if (
  document.readyState === "complete" ||
  document.readyState === "interactive"
) {
  console.log("Apifox代码生成器：页面已加载，立即初始化");
  setTimeout(initializeExtension, 500);
}

/**
 * 初始化扩展功能
 */
function initializeExtension() {
  // 如果不是Apifox页面，不执行后续操作
  if (!window.location.href.includes("apifox")) {
    console.log("不是Apifox页面，不执行初始化");
    return;
  }

  console.log("Apifox代码生成器初始化中...");

  // 立即添加按钮
  initFloatingButtons();

  // 然后再延迟添加一次，以确保在所有内容加载完毕后按钮存在
  setTimeout(initFloatingButtons, 1500);
  setTimeout(initFloatingButtons, 3000);

  // 监听URL变化（单页应用中页面切换）
  let lastUrl = location.href;
  console.log("开始监听URL变化，当前URL:", lastUrl);

  const observer = new MutationObserver(() => {
    const url = location.href;
    if (url !== lastUrl) {
      console.log("URL从", lastUrl, "变化为", url);
      lastUrl = url;

      // 移除旧按钮
      removeButtons();

      // 延迟添加新按钮以确保DOM已更新
      setTimeout(initFloatingButtons, 500);
      setTimeout(initFloatingButtons, 1500);
      setTimeout(initFloatingButtons, 3000);
    }
  });

  observer.observe(document, { subtree: true, childList: true });
  console.log("已设置MutationObserver监听页面变化");
}

/**
 * 移除已存在的按钮
 */
function removeButtons() {
  const oldButtons = document.getElementById("apifox-code-generator-buttons");
  if (oldButtons) {
    console.log("找到并移除旧按钮");
    oldButtons.remove();
  }
}

/**
 * 初始化浮动按钮
 */
function initFloatingButtons() {
  console.log("初始化浮动按钮...");

  // 如果按钮已存在，则不重复添加
  if (document.getElementById("apifox-code-generator-buttons")) {
    console.log("按钮已存在，不重复添加");
    return;
  }

  // 强制添加按钮，不进行页面检测
  addFloatingButtons();
}

/**
 * 添加浮动按钮到页面
 */
function addFloatingButtons() {
  console.log("添加浮动按钮到页面");

  // 创建浮动按钮容器
  const buttonsContainer = document.createElement("div");
  buttonsContainer.id = "apifox-code-generator-buttons";
  buttonsContainer.style.cssText = `
    position: fixed;
    right: 20px;
    bottom: 20px;
    z-index: 99999;
    display: flex;
    flex-direction: column;
    gap: 8px;
    transition: all 0.3s ease;
  `;

  // 创建复制方法按钮
  const copyMethodButton = createButton("复制方法", "#4285f4");
  copyMethodButton.addEventListener("click", function () {
    handleCopyButtonClick("copyMethod");
  });

  // 创建复制类按钮
  const copyClassButton = createButton("复制类", "#4285f4");
  copyClassButton.addEventListener("click", function () {
    handleCopyButtonClick("copyClass");
  });

  // 添加按钮到容器
  buttonsContainer.appendChild(copyMethodButton);
  buttonsContainer.appendChild(copyClassButton);

  // 添加拖拽功能
  makeDraggable(buttonsContainer);

  // 添加容器到页面
  document.body.appendChild(buttonsContainer);
  console.log("按钮已添加到页面");
}

/**
 * 创建按钮元素
 * @param {string} text 按钮文本
 * @param {string} bgColor 背景颜色
 * @returns {HTMLElement} 按钮元素
 */
function createButton(text, bgColor) {
  const button = document.createElement("button");
  button.textContent = text;
  button.style.cssText = `
    padding: 6px 10px;
    background-color: ${bgColor};
    color: white;
    border: none;
    border-radius: 3px;
    font-size: 12px;
    cursor: pointer;
    font-weight: normal;
    box-shadow: 0 1px 3px rgba(0,0,0,0.2);
    transition: all 0.2s ease;
    white-space: nowrap;
    opacity: 0.85;
  `;

  // 鼠标悬停效果
  button.addEventListener("mouseover", function () {
    this.style.backgroundColor = "#3367d6";
    this.style.opacity = "1";
  });

  button.addEventListener("mouseout", function () {
    this.style.backgroundColor = bgColor;
    this.style.opacity = "0.85";
  });

  return button;
}

/**
 * 使元素可拖拽
 * @param {HTMLElement} element 要使可拖拽的元素
 */
function makeDraggable(element) {
  let pos1 = 0,
    pos2 = 0,
    pos3 = 0,
    pos4 = 0;

  element.addEventListener("mousedown", dragMouseDown);

  function dragMouseDown(e) {
    e.preventDefault();
    // 获取鼠标位置
    pos3 = e.clientX;
    pos4 = e.clientY;
    document.addEventListener("mouseup", closeDragElement);
    document.addEventListener("mousemove", elementDrag);
  }

  function elementDrag(e) {
    e.preventDefault();
    // 计算新位置
    pos1 = pos3 - e.clientX;
    pos2 = pos4 - e.clientY;
    pos3 = e.clientX;
    pos4 = e.clientY;
    // 设置元素的新位置
    element.style.top = element.offsetTop - pos2 + "px";
    element.style.left = element.offsetLeft - pos1 + "px";
    element.style.right = "auto";
    element.style.bottom = "auto";
  }

  function closeDragElement() {
    // 停止移动
    document.removeEventListener("mouseup", closeDragElement);
    document.removeEventListener("mousemove", elementDrag);
  }
}

/**
 * 处理复制按钮点击事件
 * @param {string} action 动作类型
 */
function handleCopyButtonClick(action) {
  try {
    // 提取API信息
    const apiInfo = extractApiInfo();

    if (!apiInfo || apiInfo.path === "/") {
      showToast("无法提取API信息，请确保在API页面", true);
      return;
    }

    // 生成代码
    let code;
    if (action === "copyMethod") {
      code = generateMethodCode(apiInfo);
    } else {
      code = generateClassCode(apiInfo);
    }

    // 复制到剪贴板
    copyToClipboard(code);
    showToast("代码已复制到剪贴板！");
  } catch (error) {
    console.error("生成代码时出错:", error);
    showToast(`生成代码出错: ${error.message}`, true);
  }
}

/**
 * 检查当前页面是否是API页面
 * @returns {boolean} 是否是API页面
 */
function checkIfApiPage() {
  // 检查URL是否包含API相关关键词
  const url = window.location.href;
  if (
    url.includes("/api/") ||
    url.includes("/apis/") ||
    url.includes("/document/")
  ) {
    return true;
  }

  // 检查页面内容是否包含API相关元素
  const apiRelatedSelectors = [
    '[data-testid="api-url"]',
    ".api-url",
    ".request-url",
    ".api-path",
    ".http-method",
    ".request-method",
  ];

  for (const selector of apiRelatedSelectors) {
    if (document.querySelector(selector)) {
      return true;
    }
  }

  // 查找页面中是否有API路径相关的文本
  const pageText = document.body.textContent;
  if (
    pageText.match(/\/api\/v?\d*\/\w+/) ||
    pageText.match(/GET|POST|PUT|DELETE|PATCH/)
  ) {
    return true;
  }

  return false;
}

/**
 * 显示信息提示框
 * @param {string} message 消息
 * @param {boolean} isError 是否是错误信息
 */
function showToast(message, isError = false) {
  // 移除可能存在的旧提示
  const oldToast = document.getElementById("apifox-code-generator-toast");
  if (oldToast) {
    oldToast.remove();
  }

  // 创建新提示
  const toast = document.createElement("div");
  toast.id = "apifox-code-generator-toast";
  toast.textContent = message;
  toast.style.cssText = `
    position: fixed;
    top: 20px;
    right: 20px;
    padding: 8px 15px;
    background-color: ${isError ? "#f44336" : "#4caf50"};
    color: white;
    border-radius: 3px;
    font-size: 12px;
    z-index: 100000;
    box-shadow: 0 2px 5px rgba(0,0,0,0.2);
    transition: all 0.3s ease;
    text-align: center;
  `;

  document.body.appendChild(toast);

  // 3秒后自动消失
  setTimeout(() => {
    toast.style.opacity = "0";
    setTimeout(() => {
      if (toast.parentNode) {
        toast.remove();
      }
    }, 300);
  }, 2000);
}

/**
 * 从Apifox页面提取API信息
 * @returns {Object} API信息对象
 */
function extractApiInfo() {
  console.log("开始提取API信息...");

  // 获取API名称/描述
  let apiName = "";
  let apiDesc = "";
  let apiPath = "";
  let apiMethod = "";

  // 打印页面内的一些关键元素，帮助调试
  console.log("页面标题:", document.title);
  console.log("URL:", window.location.href);

  // 尝试直接从URL中提取API ID或路径信息
  const currentUrl = window.location.href;
  console.log("分析当前URL:", currentUrl);

  // 尝试获取API ID（在Apifox中URL通常包含API ID）
  const apiIdMatch = currentUrl.match(/\/api\/([0-9]+)/);
  if (apiIdMatch && apiIdMatch[1]) {
    const apiId = apiIdMatch[1];
    console.log("从URL中提取到API ID:", apiId);

    // 使用API ID构造一个可能的路径
    apiPath = `/api/v1/resource/${apiId}`;
    console.log("基于API ID构造的路径:", apiPath);
  }

  // 搜索页面上所有可能包含API路径的文本
  const allTexts = [];
  document.querySelectorAll("*").forEach((el) => {
    const text = el.textContent;
    if (
      text &&
      (text.includes("/api/") || text.match(/\/v\d+\//)) &&
      text.length < 200
    ) {
      allTexts.push({
        element: el.tagName,
        class: el.className,
        text: text.trim(),
      });
    }
  });

  console.log("可能包含API路径的元素:", allTexts);

  // 尝试从页面中提取完整API路径
  // 优先匹配 /api/v1/xxx 格式的路径
  const apiPathRegexPatterns = [
    /\/api\/v\d+\/[a-zA-Z0-9\-_\/]+/, // 匹配 /api/v1/xxx 格式
    /\/api\/[a-zA-Z0-9\-_\/]+/, // 匹配 /api/xxx 格式
    /\/v\d+\/[a-zA-Z0-9\-_\/]+/, // 匹配 /v1/xxx 格式
    /\/[a-zA-Z0-9\-_\/]+\/[a-zA-Z0-9\-_\/]+/, // 匹配任意两级以上路径
  ];

  // 在页面文本中查找符合API路径特征的文本
  for (const regex of apiPathRegexPatterns) {
    for (const item of allTexts) {
      const matches = item.text.match(regex);
      if (matches && matches[0] && matches[0] !== "/") {
        apiPath = matches[0];
        console.log(`找到API路径: ${apiPath}, 来源:`, item);
        break;
      }
    }
    if (apiPath && apiPath !== "/") break;
  }

  // 如果上面的方法没找到路径，尝试更通用的选择器
  if (!apiPath || apiPath === "/") {
    const pathSelectors = [
      '[data-testid="api-url"]',
      ".api-url",
      ".request-url",
      ".api-path",
      ".ant-typography strong",
      '[data-testid="request-url"]',
      ".url-content",
      "strong",
      "span",
      "div.url",
      "p",
    ];

    for (const selector of pathSelectors) {
      const elements = document.querySelectorAll(selector);
      for (const element of elements) {
        const text = element.textContent.trim();
        if (text && text.length > 1) {
          // 尝试提取路径
          for (const regex of apiPathRegexPatterns) {
            const matches = text.match(regex);
            if (matches && matches[0] && matches[0] !== "/") {
              apiPath = matches[0];
              console.log(`通过选择器 ${selector} 找到API路径: ${apiPath}`);
              break;
            }
          }

          // 如果还是没找到，但文本以"/"开头，且长度适中，不是单个斜杠，可能是一个简单路径
          if (
            (!apiPath || apiPath === "/") &&
            text.startsWith("/") &&
            text.length > 1 &&
            text.length < 50 &&
            text !== "/"
          ) {
            apiPath = text.split(" ")[0].split("?")[0]; // 提取第一部分，去除查询参数
            console.log(`提取简单路径: ${apiPath}, 选择器: ${selector}`);
          }
        }
        if (apiPath && apiPath !== "/") break;
      }
      if (apiPath && apiPath !== "/") break;
    }
  }

  // 获取请求方法（GET、POST等）
  const methodSelectors = [
    '[data-testid="http-method"]',
    ".http-method",
    ".request-method",
    ".method-tag",
    ".ant-tag",
    ".method-label",
    "span.ant-tag",
    "span",
    "div",
  ];

  // 可能的HTTP方法
  const httpMethods = ["get", "post", "put", "delete", "patch"];

  // 尝试通过不同的选择器查找HTTP方法
  for (const selector of methodSelectors) {
    const elements = document.querySelectorAll(selector);
    for (const element of elements) {
      const text = element.textContent.trim().toLowerCase();
      if (httpMethods.includes(text)) {
        apiMethod = text;
        console.log(`找到HTTP方法: ${apiMethod}, 选择器: ${selector}`);
        break;
      }
    }
    if (apiMethod) break;
  }

  // 如果仍然找不到方法，尝试从URL或其他文本中推断
  if (!apiMethod) {
    // 尝试从页面内容中查找HTTP方法
    const allText = document.body.textContent.toLowerCase();
    for (const method of httpMethods) {
      if (allText.includes(method.toUpperCase()) || allText.includes(method)) {
        apiMethod = method;
        console.log(`从页面内容推断HTTP方法: ${apiMethod}`);
        break;
      }
    }

    // 如果仍然找不到，默认使用GET
    if (!apiMethod) {
      apiMethod = "get";
      console.log("未找到HTTP方法，默认使用: GET");
    }
  }

  // 获取API名称或描述
  const titleSelectors = [
    '[data-testid="api-name"]',
    ".api-title",
    ".api-name",
    "h1.ant-typography",
    ".api-summary h1",
    ".api-header h1",
    ".ant-page-header-heading-title",
    ".api-basic-info h1",
    "h1",
    "h2",
    "h3",
    ".ant-typography",
  ];

  for (const selector of titleSelectors) {
    const elements = document.querySelectorAll(selector);
    for (const element of elements) {
      const text = element.textContent.trim();
      if (text && text.length > 0 && text.length < 100) {
        apiDesc = text;
        console.log(`找到API描述: ${apiDesc}, 选择器: ${selector}`);
        break;
      }
    }
    if (apiDesc) break;
  }

  // 如果路径不存在或者只是单个斜杠，尝试使用默认路径
  if (!apiPath || apiPath === "/") {
    console.warn("API路径不可用或只是单个斜杠，尝试使用默认路径");

    // 如果有API描述，使用它来构造一个路径
    if (apiDesc) {
      apiPath = `/api/v1/${apiDesc
        .toLowerCase()
        .replace(/[^\w\u4e00-\u9fa5]/g, "-")}`;
      console.log(`基于API描述构造的路径: ${apiPath}`);
    } else {
      // 尝试从URL中提取有用信息
      const urlPath = window.location.pathname;
      if (urlPath && urlPath.length > 1) {
        const parts = urlPath.split("/");
        if (parts.length >= 4) {
          // 假设URL格式为 /project/123/api/456
          apiPath = `/api/v1/${parts[parts.length - 1]}`;
          console.log(`从URL提取构造的API路径: ${apiPath}`);
        } else {
          // 使用一个通用的API路径和时间戳
          apiPath = `/api/v1/resource/${Date.now()}`;
          console.log(`使用通用API路径: ${apiPath}`);
        }
      } else {
        // 最后的后备方案
        apiPath = `/api/v1/resource`;
        console.log(`使用默认API路径: ${apiPath}`);
      }
    }
  }

  // 根据API路径生成合适的方法名
  apiName = generateMethodName(apiPath, apiMethod);
  console.log(`生成的方法名: ${apiName}`);

  // 检查是否有请求参数
  const paramSelectors = [
    '[data-testid="request-params"]',
    ".request-params",
    ".params-container",
    ".parameter-table",
    ".ant-table-wrapper",
    ".params-list",
    "table",
  ];

  let hasParams = false;
  for (const selector of paramSelectors) {
    if (document.querySelector(selector)) {
      hasParams = true;
      console.log(`找到参数表: ${selector}`);
      break;
    }
  }

  // 如果是GET方法，假定有参数
  if (apiMethod === "get") {
    hasParams = true;
    console.log("GET方法，默认设置hasParams=true");
  }

  // 对于POST方法通常也有参数
  if (apiMethod === "post") {
    hasParams = true;
    console.log("POST方法，默认设置hasParams=true");
  }

  // 调试信息
  console.log("最终提取的API信息:", {
    name: apiName,
    description: apiDesc,
    path: apiPath,
    method: apiMethod,
    hasParams: hasParams,
  });

  return {
    name: apiName,
    description: apiDesc,
    path: apiPath,
    method: apiMethod,
    hasParams: hasParams,
  };
}

/**
 * 根据API路径和方法生成合适的方法名
 * @param {string} path API路径
 * @param {string} method HTTP方法
 * @returns {string} 生成的方法名
 */
function generateMethodName(path, method) {
  // 移除开头的斜杠和api前缀
  let cleanPath = path
    .replace(/^\/+/, "")
    .replace(/^api\/v\d+\//, "")
    .replace(/^api\//, "");

  // 移除结尾的斜杠
  cleanPath = cleanPath.replace(/\/+$/, "");

  // 将路径分割成部分
  const parts = cleanPath.split("/");

  // 转换为camelCase
  let methodName = method;
  for (let i = 0; i < parts.length; i++) {
    if (parts[i]) {
      // 处理连字符和下划线
      const words = parts[i].split(/[-_]/);
      for (let j = 0; j < words.length; j++) {
        if (words[j]) {
          if (i === 0 && j === 0 && methodName === "get") {
            // 第一个词直接使用
            methodName += capitalizeFirstLetter(words[j]);
          } else {
            // 其他词首字母大写
            methodName += capitalizeFirstLetter(words[j]);
          }
        }
      }
    }
  }

  return methodName;
}

/**
 * 首字母大写
 * @param {string} string 输入字符串
 * @returns {string} 首字母大写的字符串
 */
function capitalizeFirstLetter(string) {
  if (!string) return "";
  return string.charAt(0).toUpperCase() + string.slice(1);
}

/**
 * 生成单个方法代码
 * @param {Object} apiInfo API信息
 * @returns {string} 生成的方法代码
 */
function generateMethodCode(apiInfo) {
  const { name, description, path, method, hasParams } = apiInfo;

  let code = "";

  // 添加注释
  if (description) {
    code += `// ${description}\n`;
  }

  // 方法声明
  code += `static async ${name}(`;

  // 添加参数
  if (hasParams || method === "get") {
    code += "params";
  }
  code += ") {\n";

  // 方法体
  code += `    return await http\n`;
  code += `        .${method}(\`${path}\``;

  // 根据HTTP方法添加参数
  if (method === "get" && hasParams) {
    code += `, {params}`;
  } else if (hasParams) {
    code += `, params`;
  }

  code += `)\n`;
  code += `        .then(Result.ofResponse)\n`;
  code += `        .catch(Result.ofCatch)\n`;
  code += `}`;

  return code;
}

/**
 * 生成类代码
 * @param {Object} apiInfo API信息
 * @returns {string} 生成的类代码
 */
function generateClassCode(apiInfo) {
  const { name, description, path, method, hasParams } = apiInfo;

  // 从路径中提取类名
  let className = extractClassName(path);

  let code = "";

  // 导入语句
  code += `import http from '../utils/http'\n`;
  code += `import Result from '../utils/result'\n\n`;

  // 类声明
  code += `export default class ${className} {\n`;

  // 添加注释
  if (description) {
    code += `    // ${description}\n`;
  }

  // 添加方法
  code += `    static async ${name}(`;

  // 添加参数
  if (hasParams || method === "get") {
    code += "params";
  }
  code += ") {\n";

  // 方法体
  code += `        return await http\n`;
  code += `            .${method}(\`${path}\``;

  // 根据HTTP方法添加参数
  if (method === "get" && hasParams) {
    code += `, {params}`;
  } else if (hasParams) {
    code += `, params`;
  }

  code += `)\n`;
  code += `            .then(Result.ofResponse)\n`;
  code += `            .catch(Result.ofCatch)\n`;
  code += `    }\n`;
  code += `}`;

  return code;
}

/**
 * 从API路径提取类名
 * @param {string} path API路径
 * @returns {string} 类名
 */
function extractClassName(path) {
  // 移除开头的斜杠和api前缀
  let cleanPath = path
    .replace(/^\/+/, "")
    .replace(/^api\/v\d+\//, "")
    .replace(/^api\//, "");

  // 获取第一段作为类名基础
  let classBaseName = cleanPath.split("/")[0] || "Api";

  // 处理连字符和下划线
  const words = classBaseName.split(/[-_]/);
  let className = "";

  for (let i = 0; i < words.length; i++) {
    if (words[i]) {
      className += capitalizeFirstLetter(words[i]);
    }
  }

  return className;
}

/**
 * 复制文本到剪贴板
 * @param {string} text 要复制的文本
 */
function copyToClipboard(text) {
  // 创建临时textarea元素
  const textarea = document.createElement("textarea");
  textarea.value = text;
  textarea.setAttribute("readonly", "");
  textarea.style.position = "absolute";
  textarea.style.left = "-9999px";

  document.body.appendChild(textarea);
  textarea.select();
  document.execCommand("copy");
  document.body.removeChild(textarea);
}
